// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.amazon.stock.taking;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.AmazonStockTaking;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(AmazonStockTaking.class)
@Setter
@Getter
public class AmazonStockTakingSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "AmazonStockTaking".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("sid", "si");
    map.put("country", "sr");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String sidShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String sidShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String sidShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String sidShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String sidShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String sidShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String sidShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String sidShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String sidShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String sidShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean sidShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean sidShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> sidInList;

  /**
   * 国家
   */
  private Long country;

  /**
   * 国家 比较(eq)
   */
  private Long countryEq;
  /**
   * 国家 比较(neq)
   */
  private Long countryNeq;
  /**
   * 国家 比较(gt)
   */
  private Long countryGt;
  /**
   * 国家 比较(gte)
   */
  private Long countryGte;
  /**
   * 国家 比较(lt)
   */
  private Long countryLt;
  /**
   * 国家 比较(lte)
   */
  private Long countryLte;
  /**
   * 国家 比较(contains)
   */
  private Long countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private Long countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private Long countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private Long countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;
  /**
   * 国家的名称 比较(eq)
   */
  private String countryNameEq;
  /**
   * 国家的名称 比较(neq)
   */
  private String countryNameNeq;
  /**
   * 国家的名称 比较(gt)
   */
  private String countryNameGt;
  /**
   * 国家的名称 比较(gte)
   */
  private String countryNameGte;
  /**
   * 国家的名称 比较(lt)
   */
  private String countryNameLt;
  /**
   * 国家的名称 比较(lte)
   */
  private String countryNameLte;
  /**
   * 国家的名称 比较(contains)
   */
  private String countryNameContains;
  /**
   * 国家的名称 比较(notcontains)
   */
  private String countryNameNotcontains;
  /**
   * 国家的名称 比较(startswith)
   */
  private String countryNameStartswith;
  /**
   * 国家的名称 比较(endswith)
   */
  private String countryNameEndswith;
  /**
   * 国家的名称 比较(isnull)
   */
  private Boolean countryNameIsnull;
  /**
   * 国家的名称 比较(isnotnull)
   */
  private Boolean countryNameIsnotnull;

  /**
   * 国家(范围搜索)
   */
  private List<Long> countryInList;

  /**
   * 最早发货日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date reportDateStart;

  /**
   * 最晚发货日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date reportDateEnd;

  /**
   * 发货日期 比较(eq)
   */
  private Date reportDateEq;
  /**
   * 发货日期 比较(neq)
   */
  private Date reportDateNeq;
  /**
   * 发货日期 比较(gt)
   */
  private Date reportDateGt;
  /**
   * 发货日期 比较(gte)
   */
  private Date reportDateGte;
  /**
   * 发货日期 比较(lt)
   */
  private Date reportDateLt;
  /**
   * 发货日期 比较(lte)
   */
  private Date reportDateLte;
  /**
   * 发货日期 比较(contains)
   */
  private Date reportDateContains;
  /**
   * 发货日期 比较(notcontains)
   */
  private Date reportDateNotcontains;
  /**
   * 发货日期 比较(startswith)
   */
  private Date reportDateStartswith;
  /**
   * 发货日期 比较(endswith)
   */
  private Date reportDateEndswith;
  /**
   * 发货日期 比较(isnull)
   */
  private Boolean reportDateIsnull;
  /**
   * 发货日期 比较(isnotnull)
   */
  private Boolean reportDateIsnotnull;

  /**
   * 交易编号(模糊搜索)
   */
  private String referenceId;

  /**
   * 交易编号 比较(eq)
   */
  private String referenceIdEq;
  /**
   * 交易编号 比较(neq)
   */
  private String referenceIdNeq;
  /**
   * 交易编号 比较(gt)
   */
  private String referenceIdGt;
  /**
   * 交易编号 比较(gte)
   */
  private String referenceIdGte;
  /**
   * 交易编号 比较(lt)
   */
  private String referenceIdLt;
  /**
   * 交易编号 比较(lte)
   */
  private String referenceIdLte;
  /**
   * 交易编号 比较(contains)
   */
  private String referenceIdContains;
  /**
   * 交易编号 比较(notcontains)
   */
  private String referenceIdNotcontains;
  /**
   * 交易编号 比较(startswith)
   */
  private String referenceIdStartswith;
  /**
   * 交易编号 比较(endswith)
   */
  private String referenceIdEndswith;
  /**
   * 交易编号 比较(isnull)
   */
  private Boolean referenceIdIsnull;
  /**
   * 交易编号 比较(isnotnull)
   */
  private Boolean referenceIdIsnotnull;

  /**
   * 交易编号(精确搜索)
   */
  private List<String> referenceIdInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * 标题(模糊搜索)
   */
  private String title;

  /**
   * 标题 比较(eq)
   */
  private String titleEq;
  /**
   * 标题 比较(neq)
   */
  private String titleNeq;
  /**
   * 标题 比较(gt)
   */
  private String titleGt;
  /**
   * 标题 比较(gte)
   */
  private String titleGte;
  /**
   * 标题 比较(lt)
   */
  private String titleLt;
  /**
   * 标题 比较(lte)
   */
  private String titleLte;
  /**
   * 标题 比较(contains)
   */
  private String titleContains;
  /**
   * 标题 比较(notcontains)
   */
  private String titleNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String titleStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String titleEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean titleIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean titleIsnotnull;

  /**
   * 标题(精确搜索)
   */
  private List<String> titleInList;

  /**
   * 运营中心(模糊搜索)
   */
  private String fulfillmentCenter;

  /**
   * 运营中心 比较(eq)
   */
  private String fulfillmentCenterEq;
  /**
   * 运营中心 比较(neq)
   */
  private String fulfillmentCenterNeq;
  /**
   * 运营中心 比较(gt)
   */
  private String fulfillmentCenterGt;
  /**
   * 运营中心 比较(gte)
   */
  private String fulfillmentCenterGte;
  /**
   * 运营中心 比较(lt)
   */
  private String fulfillmentCenterLt;
  /**
   * 运营中心 比较(lte)
   */
  private String fulfillmentCenterLte;
  /**
   * 运营中心 比较(contains)
   */
  private String fulfillmentCenterContains;
  /**
   * 运营中心 比较(notcontains)
   */
  private String fulfillmentCenterNotcontains;
  /**
   * 运营中心 比较(startswith)
   */
  private String fulfillmentCenterStartswith;
  /**
   * 运营中心 比较(endswith)
   */
  private String fulfillmentCenterEndswith;
  /**
   * 运营中心 比较(isnull)
   */
  private Boolean fulfillmentCenterIsnull;
  /**
   * 运营中心 比较(isnotnull)
   */
  private Boolean fulfillmentCenterIsnotnull;

  /**
   * 运营中心(精确搜索)
   */
  private List<String> fulfillmentCenterInList;

  /**
   * 数量
   */
  private Integer quantity;

  /**
   * 最小数量
   */
  private Integer quantityMin;

  /**
   * 最大数量
   */
  private Integer quantityMax;

  /**
   * 数量 比较(eq)
   */
  private Integer quantityEq;
  /**
   * 数量 比较(neq)
   */
  private Integer quantityNeq;
  /**
   * 数量 比较(gt)
   */
  private Integer quantityGt;
  /**
   * 数量 比较(gte)
   */
  private Integer quantityGte;
  /**
   * 数量 比较(lt)
   */
  private Integer quantityLt;
  /**
   * 数量 比较(lte)
   */
  private Integer quantityLte;
  /**
   * 数量 比较(contains)
   */
  private Integer quantityContains;
  /**
   * 数量 比较(notcontains)
   */
  private Integer quantityNotcontains;
  /**
   * 数量 比较(startswith)
   */
  private Integer quantityStartswith;
  /**
   * 数量 比较(endswith)
   */
  private Integer quantityEndswith;
  /**
   * 数量 比较(isnull)
   */
  private Boolean quantityIsnull;
  /**
   * 数量 比较(isnotnull)
   */
  private Boolean quantityIsnotnull;

  /**
   * 原因code(模糊搜索)
   */
  private String reason;

  /**
   * 原因code 比较(eq)
   */
  private String reasonEq;
  /**
   * 原因code 比较(neq)
   */
  private String reasonNeq;
  /**
   * 原因code 比较(gt)
   */
  private String reasonGt;
  /**
   * 原因code 比较(gte)
   */
  private String reasonGte;
  /**
   * 原因code 比较(lt)
   */
  private String reasonLt;
  /**
   * 原因code 比较(lte)
   */
  private String reasonLte;
  /**
   * 原因code 比较(contains)
   */
  private String reasonContains;
  /**
   * 原因code 比较(notcontains)
   */
  private String reasonNotcontains;
  /**
   * 原因code 比较(startswith)
   */
  private String reasonStartswith;
  /**
   * 原因code 比较(endswith)
   */
  private String reasonEndswith;
  /**
   * 原因code 比较(isnull)
   */
  private Boolean reasonIsnull;
  /**
   * 原因code 比较(isnotnull)
   */
  private Boolean reasonIsnotnull;

  /**
   * 原因code(精确搜索)
   */
  private List<String> reasonInList;

  /**
   * 原因(模糊搜索)
   */
  private String reasonText;

  /**
   * 原因 比较(eq)
   */
  private String reasonTextEq;
  /**
   * 原因 比较(neq)
   */
  private String reasonTextNeq;
  /**
   * 原因 比较(gt)
   */
  private String reasonTextGt;
  /**
   * 原因 比较(gte)
   */
  private String reasonTextGte;
  /**
   * 原因 比较(lt)
   */
  private String reasonTextLt;
  /**
   * 原因 比较(lte)
   */
  private String reasonTextLte;
  /**
   * 原因 比较(contains)
   */
  private String reasonTextContains;
  /**
   * 原因 比较(notcontains)
   */
  private String reasonTextNotcontains;
  /**
   * 原因 比较(startswith)
   */
  private String reasonTextStartswith;
  /**
   * 原因 比较(endswith)
   */
  private String reasonTextEndswith;
  /**
   * 原因 比较(isnull)
   */
  private Boolean reasonTextIsnull;
  /**
   * 原因 比较(isnotnull)
   */
  private Boolean reasonTextIsnotnull;

  /**
   * 原因(精确搜索)
   */
  private List<String> reasonTextInList;

  /**
   * 库存属性(模糊搜索)
   */
  private String disposition;

  /**
   * 库存属性 比较(eq)
   */
  private String dispositionEq;
  /**
   * 库存属性 比较(neq)
   */
  private String dispositionNeq;
  /**
   * 库存属性 比较(gt)
   */
  private String dispositionGt;
  /**
   * 库存属性 比较(gte)
   */
  private String dispositionGte;
  /**
   * 库存属性 比较(lt)
   */
  private String dispositionLt;
  /**
   * 库存属性 比较(lte)
   */
  private String dispositionLte;
  /**
   * 库存属性 比较(contains)
   */
  private String dispositionContains;
  /**
   * 库存属性 比较(notcontains)
   */
  private String dispositionNotcontains;
  /**
   * 库存属性 比较(startswith)
   */
  private String dispositionStartswith;
  /**
   * 库存属性 比较(endswith)
   */
  private String dispositionEndswith;
  /**
   * 库存属性 比较(isnull)
   */
  private Boolean dispositionIsnull;
  /**
   * 库存属性 比较(isnotnull)
   */
  private Boolean dispositionIsnotnull;

  /**
   * 库存属性(精确搜索)
   */
  private List<String> dispositionInList;

  /**
   * 类型(模糊搜索)
   */
  private String eventType;

  /**
   * 类型 比较(eq)
   */
  private String eventTypeEq;
  /**
   * 类型 比较(neq)
   */
  private String eventTypeNeq;
  /**
   * 类型 比较(gt)
   */
  private String eventTypeGt;
  /**
   * 类型 比较(gte)
   */
  private String eventTypeGte;
  /**
   * 类型 比较(lt)
   */
  private String eventTypeLt;
  /**
   * 类型 比较(lte)
   */
  private String eventTypeLte;
  /**
   * 类型 比较(contains)
   */
  private String eventTypeContains;
  /**
   * 类型 比较(notcontains)
   */
  private String eventTypeNotcontains;
  /**
   * 类型 比较(startswith)
   */
  private String eventTypeStartswith;
  /**
   * 类型 比较(endswith)
   */
  private String eventTypeEndswith;
  /**
   * 类型 比较(isnull)
   */
  private Boolean eventTypeIsnull;
  /**
   * 类型 比较(isnotnull)
   */
  private Boolean eventTypeIsnotnull;

  /**
   * 类型(精确搜索)
   */
  private List<String> eventTypeInList;

  /**
   * 确定数量
   */
  private Integer reconciledQuantity;

  /**
   * 最小确定数量
   */
  private Integer reconciledQuantityMin;

  /**
   * 最大确定数量
   */
  private Integer reconciledQuantityMax;

  /**
   * 确定数量 比较(eq)
   */
  private Integer reconciledQuantityEq;
  /**
   * 确定数量 比较(neq)
   */
  private Integer reconciledQuantityNeq;
  /**
   * 确定数量 比较(gt)
   */
  private Integer reconciledQuantityGt;
  /**
   * 确定数量 比较(gte)
   */
  private Integer reconciledQuantityGte;
  /**
   * 确定数量 比较(lt)
   */
  private Integer reconciledQuantityLt;
  /**
   * 确定数量 比较(lte)
   */
  private Integer reconciledQuantityLte;
  /**
   * 确定数量 比较(contains)
   */
  private Integer reconciledQuantityContains;
  /**
   * 确定数量 比较(notcontains)
   */
  private Integer reconciledQuantityNotcontains;
  /**
   * 确定数量 比较(startswith)
   */
  private Integer reconciledQuantityStartswith;
  /**
   * 确定数量 比较(endswith)
   */
  private Integer reconciledQuantityEndswith;
  /**
   * 确定数量 比较(isnull)
   */
  private Boolean reconciledQuantityIsnull;
  /**
   * 确定数量 比较(isnotnull)
   */
  private Boolean reconciledQuantityIsnotnull;

  /**
   * 未确定数量
   */
  private Integer unreconciledQuantity;

  /**
   * 最小未确定数量
   */
  private Integer unreconciledQuantityMin;

  /**
   * 最大未确定数量
   */
  private Integer unreconciledQuantityMax;

  /**
   * 未确定数量 比较(eq)
   */
  private Integer unreconciledQuantityEq;
  /**
   * 未确定数量 比较(neq)
   */
  private Integer unreconciledQuantityNeq;
  /**
   * 未确定数量 比较(gt)
   */
  private Integer unreconciledQuantityGt;
  /**
   * 未确定数量 比较(gte)
   */
  private Integer unreconciledQuantityGte;
  /**
   * 未确定数量 比较(lt)
   */
  private Integer unreconciledQuantityLt;
  /**
   * 未确定数量 比较(lte)
   */
  private Integer unreconciledQuantityLte;
  /**
   * 未确定数量 比较(contains)
   */
  private Integer unreconciledQuantityContains;
  /**
   * 未确定数量 比较(notcontains)
   */
  private Integer unreconciledQuantityNotcontains;
  /**
   * 未确定数量 比较(startswith)
   */
  private Integer unreconciledQuantityStartswith;
  /**
   * 未确定数量 比较(endswith)
   */
  private Integer unreconciledQuantityEndswith;
  /**
   * 未确定数量 比较(isnull)
   */
  private Boolean unreconciledQuantityIsnull;
  /**
   * 未确定数量 比较(isnotnull)
   */
  private Boolean unreconciledQuantityIsnotnull;

  /**
   * 站点(模糊搜索)
   */
  private String region;

  /**
   * 站点 比较(eq)
   */
  private String regionEq;
  /**
   * 站点 比较(neq)
   */
  private String regionNeq;
  /**
   * 站点 比较(gt)
   */
  private String regionGt;
  /**
   * 站点 比较(gte)
   */
  private String regionGte;
  /**
   * 站点 比较(lt)
   */
  private String regionLt;
  /**
   * 站点 比较(lte)
   */
  private String regionLte;
  /**
   * 站点 比较(contains)
   */
  private String regionContains;
  /**
   * 站点 比较(notcontains)
   */
  private String regionNotcontains;
  /**
   * 站点 比较(startswith)
   */
  private String regionStartswith;
  /**
   * 站点 比较(endswith)
   */
  private String regionEndswith;
  /**
   * 站点 比较(isnull)
   */
  private Boolean regionIsnull;
  /**
   * 站点 比较(isnotnull)
   */
  private Boolean regionIsnotnull;

  /**
   * 站点(精确搜索)
   */
  private List<String> regionInList;

  /**
   * 国家编码(模糊搜索)
   */
  private String countryCode;

  /**
   * 国家编码 比较(eq)
   */
  private String countryCodeEq;
  /**
   * 国家编码 比较(neq)
   */
  private String countryCodeNeq;
  /**
   * 国家编码 比较(gt)
   */
  private String countryCodeGt;
  /**
   * 国家编码 比较(gte)
   */
  private String countryCodeGte;
  /**
   * 国家编码 比较(lt)
   */
  private String countryCodeLt;
  /**
   * 国家编码 比较(lte)
   */
  private String countryCodeLte;
  /**
   * 国家编码 比较(contains)
   */
  private String countryCodeContains;
  /**
   * 国家编码 比较(notcontains)
   */
  private String countryCodeNotcontains;
  /**
   * 国家编码 比较(startswith)
   */
  private String countryCodeStartswith;
  /**
   * 国家编码 比较(endswith)
   */
  private String countryCodeEndswith;
  /**
   * 国家编码 比较(isnull)
   */
  private Boolean countryCodeIsnull;
  /**
   * 国家编码 比较(isnotnull)
   */
  private Boolean countryCodeIsnotnull;

  /**
   * 国家编码(精确搜索)
   */
  private List<String> countryCodeInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
